Use process shim in WorkerJavaScriptBackend - #37

…ript backend

Executions accept a stdin value, passed as bytes or a string, that the
module reads through process.stdin. The runtime forwards it down the
module exec path, the backend normalizes it to bytes, bounds it by a
new maxStdinBytes option, and hands it to the runner as evaluate
context. The runner shims process.stdin as a non-TTY async iterable
that yields the supplied bytes once and then ends, so both for-await
and manual iteration read to completion.

…te streams

The runner captured console output into a single list tagged with
textual level prefixes, which the backend mapped back to stdout or
stderr. Replace that with stream-tagged capture: console.log and
console.info record to stdout, console.warn and console.error to
stderr, and process.stdout.write and process.stderr.write record their
raw bytes to the matching stream without an added newline.

Console lines carry their own trailing newline, so the backend now
emits each captured entry verbatim rather than appending one. The
per-stream byte and event ceilings and the truncation marker are
preserved.

Add an end-to-end case asserting process.cwd() tracks the exec cwd and
that argv and platform carry their inert defaults, pinning the shim
surface that the env, stdin, and stdout work left untested.

The host and stub exec paths gained env and stdin, but the
client-facing RuntimeExecOptions still omitted them, so callers reaching
the runtime through getWorkspace(stub) could not pass either. Add both
fields; the client already forwards the whole options object, and env
maps and byte stdin survive the capnweb boundary unchanged.

The exec handler now forwards env and stdin from the request body into
runtime.exec, so a posted module can read process.env and process.stdin.
Document the extended request shape and add a smoke-test recipe that
pipes stdin and reads an env value.

Add a section to the JavaScript runtime doc describing the process shim:
caller-supplied env exposed through process.env with the host
environment hidden, caller-supplied stdin as a non-interactive
async-iterable bounded by maxStdinBytes, stdout and stderr capture with
console routing, and inert argv, cwd, and platform. List maxStdinBytes
among the configurable byte limits.

Add a test asserting an oversized stdin fails the run before the loader
is invoked.

Caller-supplied env crossed the boundary unchecked and unbounded while
source, input, and stdin all had a ceiling. Add assertEnv to reject a
non-object env or a non-string value and to bound the total key and
value bytes with a new maxEnvBytes option, defaulting to one mebibyte.
Harden normalizeStdin to reject a value that is neither a string nor a
Uint8Array rather than letting it slip past the stdin ceiling check.